

from idlelib.colorizer import prog_group_name_to_tag
from pathlib import Path
import re
from pathlib import Path
from docx.shared import Cm
from docx.shared import Inches
import csv
from langchain_community.vectorstores import Chroma
import re
from langchain_community.embeddings import DashScopeEmbeddings
import os
from openai import OpenAI
from docx import Document
from docx.oxml.ns import qn
from docx.shared import Pt

os.environ["QIANFAN_AK"] = "SGbbQdjFjlKurTfUIjYM0Q4P"
os.environ["QIANFAN_SK"] = "lb1tKvDGRhqLZYH4ZYpke6Vco9n9X8Xv"


def convert_markdown_headings(md_content, base_prefix="3.1.1"):
    """
    根据基础前缀动态编号Markdown标题

    :param md_content: Markdown文档内容
    :param base_prefix: 基础编号前缀，如"3.1.1"
    :return: 转换后的文档内容
    """
    # 解析基础前缀
    prefix_parts = (base_prefix + ".1").split('.')

    # 初始化计数器
    level1_counter = int(prefix_parts[-1]) if prefix_parts else 1
    level2_counter = 1
    level3_counter = 1
    level4_counter = 1

    # 获取基础前缀的前部分
    base_str = '.'.join(prefix_parts[:-1]) + '.' if len(prefix_parts) > 1 else ""

    # 按行处理文档
    lines = md_content.split('\n')
    output_lines = []

    for line in lines:
        # 处理一级标题
        if line.startswith('# '):
            # 生成编号：base_str + level1_counter
            new_title = f"{base_str}{level1_counter} {line[2:].strip()}"
            output_lines.append(new_title)
            level1_counter += 1
            level2_counter = 1  # 重置二级计数器
            continue

        # 处理二级标题
        if line.startswith('## '):
            # 生成编号：base_str + level1_counter-1 + '.' + level2_counter
            new_title = f"{base_str}{level1_counter}.{level2_counter} {line[3:].strip()}"
            output_lines.append(new_title)
            level2_counter += 1
            level3_counter = 1  # 重置三级计数器
            continue

        # 处理三级标题
        if line.startswith('### '):
            # 生成编号：base_str + level1_counter-1 + '.' + level2_counter-1 + '.' + level3_counter
            new_title = f"{base_str}{level1_counter}.{level2_counter}.{level3_counter} {line[4:].strip()}"
            output_lines.append(new_title)
            level3_counter += 1
            level4_counter = 1  # 重置四级计数器
            continue

        # 处理四级标题
        if line.startswith('#### '):
            # 生成编号：base_str + level1_counter-1 + '.' + level2_counter-1 + '.' + level3_counter-1 + '.' + level4_counter
            new_title = f"{base_str}{level1_counter}.{level2_counter}.{level3_counter}.{level4_counter} {line[5:].strip()}"
            output_lines.append(new_title)
            level4_counter += 1
            continue
        # 其他行直接保留
        output_lines.append(line)
    # 返回转换后的文档
    return '\n'.join(output_lines)


def is_leaf_title(idx, lines, current_level):
    """判断当前标题是否为最后一级"""
    for i in range(idx + 1, len(lines)):
        line = lines[i]
        next_level = (len(line) - len(line.lstrip(" "))) // 2
        if next_level > current_level:
            return False
        elif next_level <= current_level:
            break
    return True


def doc_llm_generation1(con):
    os.environ["DASHSCOPE_API_KEY"] = "sk-5c6689dccd074a739c78ef7d1d780148"
    client = OpenAI(
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
    )
    completion = client.chat.completions.create(
        model="deepseek-v3",
        messages=[
            {"role": "system", "content": '''
            第一步：投标标书的目录，目录如下 ：
            "
                - 1. 技术评审索引表
                - 2. 技术规范书应答
                  - 2.1 ★技术规范书偏离表
                  - 2.2 技术规范书中明确要求投标人提供的其他相关文件
                    - 2.2.1 技术规范书相关承诺
                    - 2.2.2 相关方案
                - 3. 技术部分评审材料
                  - 3.1 ★项目团队
                    - 3.1.1 项目团队清单
                    - 3.1.2 工作经历承诺书
                    - 3.1.3 项目团队人员详情
                    - 3.1.4 项目团队社保证明
                  - 3.2 研发实力
                    - 3.2.1 计算机软著清单
                    - 3.2.2 计算机软著证明材料
                    - 3.2.3 国家级科学数据标准制定
                  - 3.3 支撑实施方案
                    - 3.3.1 对天翼视联整体需求理解与研究分析
                    - 3.3.2 针对本项目技术支撑服务
                    - 3.3.3 驻场服务方案及流程
                    - 3.3.4 离场服务方案及流程
                  - 3.4 人员现场管理方案
                    - 3.4.1 驻场入场人员管理
                    - 3.4.2 人员考勤管理
                    - 3.4.3 绩效考评管理
                    - 3.4.4 法务合规管理
                    - 3.4.5 人员纠纷解决措施
                    - 3.4.6 核心人员稳定性管理
                    - 3.4.7 人员岗位胜任能力评估管理
                    - 3.4.8 有效输送人员管理
                    - 3.4.9 需求响应管理
                    - 3.4.10 外包人员准入管理
                    - 3.4.11 项目管理方案
                  - 3.5 服务交付保障方案
                    - 3.5.1 服务质量保障措施
                    - 3.5.2 团队高效运营措施
                    - 3.5.3 进度管控措施
                    - 3.5.4 优质增效措施
                    - 3.5.5 服务响应速度措施
                    - 3.5.6 质量控制措施
                    - 3.5.7 交付文档质量控制措施
                    - 3.5.8 多维度质量控制及保障措施
                    - 3.5.9 项目团队稳定性保证措施
                    - 3.5.10 知识转移交接保障机制
                    - 3.5.11 风险防控日常保障机措施
                    - 3.5.12 风险管理方案
                  - 3.6 安全及保密管理方案
                    - 3.6.1 人员安全管理
                    - 3.6.2 信息安全管理
                    - 3.6.3 工作安全管理
                    - 3.6.4 网络接口安全管理
                    - 3.6.5 网络安全等级保护管理
                    - 3.6.6 保密措施和制度
                  - 3.7 应急处理方案
                    - 3.7.1 人员工伤应急处理
                    - 3.7.2 人员离职应急处理
                    - 3.7.3 旷工行为应急处理
                    - 3.7.4 离场纠纷应急处理
                    - 3.7.5 临时人员需求调配应急方案
                    - 3.7.6 突发事件应急处理
                - 4. 其他免费增值服务
                  - 4.1 可为天翼视联免费提供的其他附加服务内容
                    - 4.1.1 咨询与规划服务
                    - 4.1.2 培训服务
                    - 4.1.3 前瞻技术支持
                    - 4.1.4 开源技术支持"。

            第二步：你需要根据user的query到第一步找到对应的目录章节编号，记住章节编号。
            第三步：你需要在user的source_content找到每一个章节的#，##，###等,需要用编号3.1.1替换掉每一个章节前面的'#',根据第二步中的编号替换
            如：
            #：3.1.1
            ##：3.1.1.1
            ##：3.1.1.2
            第四步：你只需要按照上面的步骤做完，不允许你做总结，输出的时候不要遗漏其他的信息，包括像图片路径，表格路径，禁止回答其他内容。
            第五步：除了上述要求，其他的不要修改，也不要做总结
            '''},
            {"role": "user", "content": con},
        ],
    )
    return completion.choices[0].message.content


def doc_llm_generation2(con):
    import os
    from openai import OpenAI
    os.environ["DASHSCOPE_API_KEY"] = "sk-5c6689dccd074a739c78ef7d1d780148"
    client = OpenAI(
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
    )
    completion = client.chat.completions.create(
        model="deepseek-v3",
        messages=[
            {"role": "system", "content": '''
            第一步：根据user的值，一个是query，一个是source_content.
            第二步：根据query去source_content找相同的章节标题或者是相似的章节标题，如果找到一级标题，那就返回一级标题的所有内容，包括二级标题的所有内容，三级标题的所有内容等；如果找到是二级标题也是按照这种逻辑；如果是三级标题也是这种思路，等等以此类推。
            第三步：你所返回的所有内容格式不得变动，输入是怎么样的，就返回什么样的内容，不得遗漏内容，不得缺失内容。
            第四步：输出格式是docx文件的风格,禁止用markdown风格输出，除了上述要求，其他的不要修改，也不要做总结,
            '''},
            {"role": "user", "content": con},
        ],
    )
    return completion.choices[0].message.content


def doc_llm_generation(con):
    import os
    from openai import OpenAI
    os.environ["DASHSCOPE_API_KEY"] = "sk-5c6689dccd074a739c78ef7d1d780148"
    client = OpenAI(
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
    )
    completion = client.chat.completions.create(
        model="deepseek-v3",
        messages=[
            {"role": "system", "content": '''
            你是一个写投标标书的小助手，根据user提供的content，完成以下的要求。
            第一content是段落内容，你需要将不同的段落整理成docx文件的格式，
            第二每个段落需要首行缩进俩个占位字符，段落之间要有空一行，
            第三你需要判断，第一个段落是不是完整的一个句子，或者完整的一个段落，如果不是，你需要根据上下文整理成完整的一句话，或者完整的一个段落。
            第四你需要判断，最后个段落是不是完整的一句话，或者完整的一个段落，如果不是完整的一个段落或者完整的一句话，你需要整理成一段话，或者完整的一个段落 。
            第五，如果有章节号，需要去掉。
            输出格式是docx文件的风格,禁止用markdown风格输出，除了上述要求，其他的不要修改，也不要做总结,
            '''},
            {"role": "user", "content": con},
        ],
    )
    return completion.choices[0].message.content


def doc_llm_generation4(con):
    import os
    from openai import OpenAI
    os.environ["DASHSCOPE_API_KEY"] = "sk-5c6689dccd074a739c78ef7d1d780148"
    client = OpenAI(
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
    )
    completion = client.chat.completions.create(
        model="deepseek-v3",
        messages=[
            {"role": "system", "content": '''
            你是一个写投标标书的小助手，根据user提供的content，完成以下的要求。
            第一content是段落内容，你需要将不同的段落整理成docx文件的格式，
            第二每个段落需要首行缩进俩个占位字符，段落之间要有空一行，
            第三你需要判断，第一个段落是不是完整的一个句子，或者完整的一个段落，如果不是，你需要根据上下文整理成完整的一句话，或者完整的一个段落。
            第四你需要判断，最后个段落是不是完整的一句话，或者完整的一个段落，如果不是完整的一个段落或者完整的一句话，你需要整理成一段话，或者完整的一个段落 。
            第五，如果有章节号，需要去掉。
            输出格式是docx文件的风格,禁止用markdown风格输出，除了上述要求，其他的不要修改，也不要做总结,
            '''},
            {"role": "user", "content": con},
        ],
    )
    return completion.choices[0].message.content


def doc_llm_generation3(con):
    import os
    from openai import OpenAI
    os.environ["DASHSCOPE_API_KEY"] = "sk-5c6689dccd074a739c78ef7d1d780148"
    client = OpenAI(
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        base_url="https://dashscope.aliyuncs.com/compatible-mode/v1"
    )
    completion = client.chat.completions.create(
        model="deepseek-v3",
        messages=[
            {"role": "system", "content": '''
                你是一个写投标标书的小助手，根据user提供的content，完成以下的要求，按照以下步骤来。

                第一步：投标标书的目录，目录如下 ：
                "
                    - 1. 技术评审索引表
                    - 2. 技术规范书应答
                      - 2.1 ★技术规范书偏离表
                      - 2.2 技术规范书中明确要求投标人提供的其他相关文件
                        - 2.2.1 技术规范书相关承诺
                        - 2.2.2 相关方案
                    - 3. 技术部分评审材料
                      - 3.1 ★项目团队
                        - 3.1.1 项目团队清单
                        - 3.1.2 工作经历承诺书
                        - 3.1.3 项目团队人员详情
                        - 3.1.4 项目团队社保证明
                      - 3.2 研发实力
                        - 3.2.1 计算机软著清单
                        - 3.2.2 计算机软著证明材料
                        - 3.2.3 国家级科学数据标准制定
                      - 3.3 支撑实施方案
                        - 3.3.1 对天翼视联整体需求理解与研究分析
                        - 3.3.2 针对本项目技术支撑服务
                        - 3.3.3 驻场服务方案及流程
                        - 3.3.4 离场服务方案及流程
                      - 3.4 人员现场管理方案
                        - 3.4.1 驻场入场人员管理
                        - 3.4.2 人员考勤管理
                        - 3.4.3 绩效考评管理
                        - 3.4.4 法务合规管理
                        - 3.4.5 人员纠纷解决措施
                        - 3.4.6 核心人员稳定性管理
                        - 3.4.7 人员岗位胜任能力评估管理
                        - 3.4.8 有效输送人员管理
                        - 3.4.9 需求响应管理
                        - 3.4.10 外包人员准入管理
                        - 3.4.11 项目管理方案
                      - 3.5 服务交付保障方案
                        - 3.5.1 服务质量保障措施
                        - 3.5.2 团队高效运营措施
                        - 3.5.3 进度管控措施
                        - 3.5.4 优质增效措施
                        - 3.5.5 服务响应速度措施
                        - 3.5.6 质量控制措施
                        - 3.5.7 交付文档质量控制措施
                        - 3.5.8 多维度质量控制及保障措施
                        - 3.5.9 项目团队稳定性保证措施
                        - 3.5.10 知识转移交接保障机制
                        - 3.5.11 风险防控日常保障机措施
                        - 3.5.12 风险管理方案
                      - 3.6 安全及保密管理方案
                        - 3.6.1 人员安全管理
                        - 3.6.2 信息安全管理
                        - 3.6.3 工作安全管理
                        - 3.6.4 网络接口安全管理
                        - 3.6.5 网络安全等级保护管理
                        - 3.6.6 保密措施和制度
                      - 3.7 应急处理方案
                        - 3.7.1 人员工伤应急处理
                        - 3.7.2 人员离职应急处理
                        - 3.7.3 旷工行为应急处理
                        - 3.7.4 离场纠纷应急处理
                        - 3.7.5 临时人员需求调配应急方案
                        - 3.7.6 突发事件应急处理
                    - 4. 其他免费增值服务
                      - 4.1 可为天翼视联免费提供的其他附加服务内容
                        - 4.1.1 咨询与规划服务
                        - 4.1.2 培训服务
                        - 4.1.3 前瞻技术支持
                        - 4.1.4 开源技术支持"。
                第二步：根据user的content，在第一步中找到对应的目录位置。
                第三步：根据整体目录上下文信息，对user的content写一个对应的内容。
                第四步：第三步中的内容字数不超过1000字。 
            '''},
            {"role": "user", "content": con},
        ],
    )
    return completion.choices[0].message.content


def search_doc_content(query):
    # embedding = QianfanEmbeddingsEndpoint()
    embeddings = DashScopeEmbeddings(
        model="text-embedding-v2",
        dashscope_api_key="sk-5c6689dccd074a739c78ef7d1d780148",
    )
    db = Chroma(persist_directory="D:\\hbyt\\project\\aibid\\db\\d1", embedding_function=embeddings)
    results = db.similarity_search(query, k=10)
    # for r in results:
    #     print("+++++++++++++++++++++++++++++++++++++++++++++++++++++++")
    #     print(r.page_content)
    # print("+++++++++++++++++++++++++++++++++++++")
    result = db.similarity_search_with_score(query, k=1)
    # print("相似的值：",result)
    for doc, score in result:
        similarity = 1 / (1 + score)  # 将距离转换为相似度（粗略处理）
        # print("相似的值：",similarity)
        if similarity > 0.5:
            # print(f"文档内容：{doc.page_content}")
            print(f"相似度（近似值）：{similarity:.4f}")
            return results
        else:
            return None

            # return results[0].page_content
    #     else:
    #         return doc_llm_generation(query)

    # similarity = SequenceMatcher(None, query, results[0].page_content).ratio()
    # print(similarity)
    # if similarity >0.9:
    #     print(similarity)
    #     return results[0].page_content
    # else:
    #      return doc_llm_generation(query)
    # return  results


def set_run_font(run, font_name, font_size_pt, bold=True):
    run.font.name = font_name
    run._element.rPr.rFonts.set(qn('w:eastAsia'), font_name)
    run.font.size = Pt(font_size_pt)
    run.font.bold = bold


def add_title(doc, text):
    para = doc.add_paragraph()
    run = para.add_run(text)
    run.font.name = '宋体'
    run._element.rPr.rFonts.set(qn('w:eastAsia'), '宋体')
    run.font.size = Pt(14)  # 四号
    run.bold = True



def write_csv_to_docx(doc, csv_path):
    # # 创建 Word 文档对象
    # doc = Document()
    # 设置字体为宋体（表格内容）
    def set_cell_font(cell, text, font_size=10.5):
        run = cell.paragraphs[0].add_run(text)
        run.font.name = '宋体'
        run._element.rPr.rFonts.set(qn('w:eastAsia'), '宋体')
        run.font.size = Pt(font_size)
    # 打开 CSV 文件
    with open(csv_path, 'r', encoding='utf-8-sig') as f:
        reader = list(csv.reader(f))
        if not reader:
            print("CSV 文件为空")
            return
        # 创建表格（行数，列数）
        table = doc.add_table(rows=len(reader), cols=len(reader[0]))
        table.style = 'Table Grid'
        # 填充表格内容
        for row_idx, row in enumerate(reader):
            for col_idx, cell_value in enumerate(row):
                cell = table.cell(row_idx, col_idx)
                set_cell_font(cell, cell_value, font_size=10.5)
def markdown_to_docx(md_text, doc, title):
    lines = md_text.splitlines()
    pattern = r'^(\d+(?:\.\d+)*)(?:\.|\s)'
    match = re.match(pattern, title.strip())
    match.group(1)
    collection = []
    collection.append(match.group(1))
    for line in lines:
        if not line.strip():
            continue  # 跳过空行
        else:
            # 插入 PNG 图片
            img_match1=re.search(r'!\[.*?\]\(([^)]+\.jpeg)\)', line)
            img_match = re.search(r'!\[.*?\]\(([^)]+\.png)\)', line)
            if img_match:
                img_path = img_match.group(1)
                try:
                    doc.add_picture(img_path, width=Inches(5))
                except Exception as e:
                    doc.add_paragraph(f"[图片插入失败: {img_path}] 错误: {e}")
                continue
            if img_match1:
                img_path = img_match1.group(1)
                try:
                    doc.add_picture(img_path, width=Inches(5))
                except Exception as e:
                    doc.add_paragraph(f"[图片插入失败: {img_path}] 错误: {e}")
                continue
            # 插入 CSV 表格
            csv_match = re.search(r'\[.*?\]\(([^)]+\.csv)\)', line)
            if csv_match:
                csv_path = csv_match.group(1)
                write_csv_to_docx(doc, Path(csv_path))
                continue
            def has_section_number(text):
                pattern = r'^\d+(\.\d+)*\s+'
                return bool(re.match(pattern, text.strip()))

            def replace_single_number(line, new_number):
                # 匹配开头编号：如 1.1.1 或 1.1.1.
                match = re.match(r'^(\s*)(\d+(?:\.\d+)*)([.\s]+)(.*)', line)
                if match:
                    indent, _, sep, title = match.groups()
                    return f"{indent}{new_number}{sep}{title}"
                return line

            def increment_any_number(number_str: str) -> str:
                """
                输入形如 '3'、'3.2'、'3.2.1' 的编号字符串，
                返回最后一段数字递增1的新编号字符串。
                """
                if not number_str.strip():
                    return "1"
                parts = number_str.strip().split(".")
                try:
                    parts = [int(p) for p in parts]
                except ValueError:
                    raise ValueError("编号中必须全部是数字组成，如 '1.2.3'")
                parts[-1] += 1
                return ".".join(str(p) for p in parts)

            def get_last_element(arr):
                return arr[-1] if arr else None
            if has_section_number(line):
                # 获取最后一个
                # new_number = get_last_element(collection)
                # 其他普通行
                # doc.add_paragraph(line)
                add_title(doc, line)
                # collection.append(increment_any_number(str(new_number)))
            else:
                # 其他普通行
                para = doc.add_paragraph(line)
                # 首行缩进2个字符
                para.paragraph_format.first_line_indent = Pt(21)

def count_heading_level(line):
    """统计开头 # 的数量"""
    stripped = line.lstrip()
    return len(stripped) - len(stripped.lstrip('#'))

def reduce_one_heading_hash(line):
    """将 Markdown 标题的 # 减少一个"""
    stripped = line.lstrip()
    level = count_heading_level(stripped)
    new_level = max(1, level - 1)
    content = stripped[level:].strip()
    return f"{'#' * new_level} {content}\n"
def get_first_heading_hash_count(md_lines):
    """获取第一行带有#的标题中#的数量"""
    for line in md_lines:
        stripped = line.lstrip()
        if stripped.startswith('#'):
            return len(stripped) - len(stripped.lstrip('#'))
    return 0

def reduce_one_heading_hash(line):
    """将标题的#减少一个，最少为#"""
    stripped = line.lstrip()
    count = len(stripped) - len(stripped.lstrip('#'))
    content = stripped[count:].strip()
    new_count = max(1, count - 1)
    return f"{'#' * new_count} {content}\n"

def reduce_headings_once(md_lines):
    """将所有标题行的#减少一级"""
    new_lines = []
    for line in md_lines:
        stripped = line.lstrip()
        if stripped.startswith('#'):
            new_lines.append(reduce_one_heading_hash(line))
        else:
            new_lines.append(line)
    return new_lines

def process_until_level_one(md_path):
    """递归处理，直到第一个标题为#"""
    with open(md_path, 'r', encoding='utf-8') as f:
        lines = f.readlines()

    count = get_first_heading_hash_count(lines)
    if count <= 1:
        # print("层级达到最低")
        return
    # 降级标题
    new_lines = reduce_headings_once(lines)
    # 写回文件
    with open(md_path, 'w', encoding='utf-8') as f:
        f.writelines(new_lines)
    # 递归调用
    process_until_level_one(md_path)

def write_outline_to_docx(md_path, output_path):
    doc = Document()
    doc.add_page_break()
    with open(md_path, 'r', encoding='utf-8') as f:
        content=f.read()
    dir = doc.add_paragraph()
    body_run = dir.add_run(content)
    set_run_font(body_run, '宋体', 10.5, bold=True)
    # 插入分页符
    doc.add_page_break()
    with open(md_path,'r', encoding='utf-8') as f:
        lines = [line for line in f if line.strip().startswith("-")]
    for idx, line in enumerate(lines):
        level = (len(line) - len(line.lstrip(" "))) // 2
        title = line.strip("- ").strip()
        add_title(doc, title)
        if is_leaf_title(idx, lines, level):
            content = ''
            if search_doc_content(re.sub(r'^\d+(\.\d+)*\s*', '', title)) is not None:
                with open(search_doc_content(re.sub(r'^\d+(\.\d+)*\s*', '', title))[0].metadata["source_md"], "r",
                          encoding="utf-8") as f:
                    content = f.read()
                template = "query:" + re.sub(r'^\d+(\.\d+)*\s*', '', title) + "\n" + "source_content:" + "\n" + content
                content = doc_llm_generation2(template)
            else:
                content = "无"
            match = re.search(r"\b(\d+(?:\.\d+)*)", title)
            converted_content = ""
            if match:
                with open("temp.md", 'w', encoding='utf-8') as f:
                    f.write(content)
                process_until_level_one("temp.md")
                # 降低层级
                # first = read_first_line("temp.md")

                # 自动化转换标题
                with open("temp.md", 'r', encoding='utf-8') as f:
                    c=f.read()
                converted_content = convert_markdown_headings(c, match.group(1))
            else:
                print("未找到编号")
            body = doc.add_paragraph()
            body_run = body.add_run(markdown_to_docx(converted_content, doc,title))
            set_run_font(body_run, '宋体', 10.5, bold=True)
            os.remove("temp.md")
    doc.save(output_path)


# 用法示例
write_outline_to_docx(
    "D:\\hbyt\\AI智能投标\\典型招标要求和投标文件\\典型投标标书目录\\投标文件-技术部分-天翼视联6.12终版.md",
    "D:\\hbyt\\AI智能投标\\典型投标标书目录\\word\\常规目录\\标准目录\\测试\\投标文件.docx")
